/*-------------------------------------*/
/*            author: Fabian           */
/*              老师主JS程序               */
/*-------------------------------------*/

//设置填充的空白图片（s.gif）的本地路径，默认是http://www.extjs.com/s.gif
Ext.BLANK_IMAGE_URL = 'EXT/resources/images/default/s.gif';

Ext.onReady(function(){        
 	
 	//开启提示功能
 	Ext.QuickTips.init();
 	
 	//显示更新皮肤的下拉框
 	changeSkin();
 	
 	/*---------------布局部分----------------*/
 	/* 定义基本布局的上，下，左，右，中的五个部分  */
 	/*-------------------------------------*/
 	
 	/*上部（北部）*/
	var top_cmp = new Ext.BoxComponent({ 
    	id: 'top_part',
        region:'north',
        el: 'north',
        height: 49
    }); 
    
    /*底部（南部）*/             
    var foot_cmp = new Ext.BoxComponent({ 
    	id: 'foot_part',
    	region:'south',
        el: 'south',
        height: 30
    });	   
    
   	/*右边（东部），工具栏*/
   	var right_cmp = new Ext.Panel({
   		id: 'tool_bar',
        region:'east',
        title: '工具',
        collapsible: true,
        split:true,
        iconCls: 'tool_bar_icon',
        width: 280,
        minSize: 180,
        maxSize: 280,
        layout:'fit',
        margins:'0 5 0 0',
        items:
            new Ext.TabPanel({
                border:false,
                tabPosition:'bottom',
                items:[{
                	//加载包含计算器的文件，并且可以执行JavaScript
                    autoLoad: {url: 'inc/counter.html', scripts: true},
                    title: '计算器',
                    iconCls: 'calculator_icon',
                    //设置此Panel背景颜色和计算器的颜色一致
                    bodyStyle: 'background-color: #D9E8FB',
                    autoScroll:true                    
                }                
                /*在线用户聊天
                , {
                    title: '在线用户',
                    autoScroll:true,
                    iconCls: 'online_icon',
                    layout:'accordion',
			        layoutConfig:{
			            animate:true
			        },
			        items: [{
			            title:'在线老师',
			            iconCls:'own_info',
			            border:false,
			            items: [{
			            	id: 'online_tch',
			            	xtype: 'treepanel',
			            	renderTo: 'treeOne',
			            	border: false,
			            	//隐藏根节点
			            	rootVisible: false,
			            	root: new Ext.tree.AsyncTreeNode({
			            		id: 'tch_online',
			            		text: '在线老师',
			            		children: [{
				                    text: '张飞',
				                    iconCls: 'online-user',
				                    leaf: true
				                }]
			            	})
			            }]
			        }, {
			            title:'在线学生',
			            iconCls:'own_info',
			            border: false,
			            items: [{
			            	id: 'online_stu',
			            	xtype: 'treepanel',
			            	renderTo: 'treeTwo',
			            	border: false,
			            	//隐藏根节点
			            	rootVisible: false,
			            	root: new Ext.tree.AsyncTreeNode({
			            		id: 'stu_online',
			            		text: '在线学生',
			            		children: [{
				                    text: '李四',
				                    iconCls: 'online-user',
				                    leaf: true
				                }]
			            	})
			            }]
			        }]
                }*/
                ]
          })
   	});
   	
   	/*左边（西部），菜单栏*/    	   	
   	var left_cmp = new Ext.Panel({
   		id: 'menu_bar',
        region:'west',
        title:'老师应用菜单',
        split:true,
        iconCls:'user_bar_icon',
        width: 200,
        minSize: 170,
        maxSize: 240,
        collapsible: true,
        margins:'0 0 0 5',
        layout:'accordion',
        layoutConfig:{
            animate:true
        },
        items: [{
            title:'师生互动',
            iconCls:'stu_tch_interaction',
            border:false,
            items: [{
            	id: 'stu_tch_interact',
            	xtype: 'treepanel',
            	renderTo: 'tree1',
            	border:false,
            	//隐藏根节点
            	rootVisible: false,
            	root: new Ext.tree.AsyncTreeNode({
            		text: '师生互动',
            		children: [{
	                    id: 'ask_answer_column',
	                    text: '问答版块',
	                    iconCls: 'tree-first',
	                    leaf: true
	                }, {
	                    id: 'discuss_column',
	                    text: '讨论版块',
	                    iconCls: 'tree-first',
	                    leaf: true
	                }]
            	})
            }]
        },{
            title:'公告信息管理',
            border:false,
            iconCls:'notice_mgr_icon',
            items: [{
            	id: 'notice_mgr',
            	xtype: 'treepanel',
            	renderTo: 'tree3',
            	border:false,
            	//隐藏根节点
            	rootVisible: false,
            	root: new Ext.tree.AsyncTreeNode({
            		text: '公告管理',
            		children: [{
	                    id: 'mgr_notice',
	                    text: '公告管理',
	                    iconCls: 'tree-first',
	                    leaf: true
	                }]
            	})
            }]
       },{
            title:'个人信息管理',
            border:false,
            iconCls:'own_info',
            items: [{
            	id: 'ownInfo_mgr',
            	xtype: 'treepanel',
            	renderTo: 'tree4',
            	border:false,
            	//隐藏根节点
            	rootVisible: false,
            	root: new Ext.tree.AsyncTreeNode({
            		text: '个人信息管理',
            		children: [{
	                    id: 'own_info',
	                    text: '查看个人信息',
	                    iconCls: 'tree-first',
	                    leaf: true
	                }, {
	                    id: 'modify_info',
	                    text: '修改个人信息',
	                    iconCls: 'tree-first',
	                    leaf: true
	                }]
            	})
            }]
       }/*,{
            title:'学生信息管理',
            border:false,
            iconCls:'user_edit',
            items: [{
            	id: 'student_mgr',
            	xtype: 'treepanel',
            	renderTo: 'tree3',
            	border:false,
            	//隐藏根节点
            	rootVisible: false,
            	root: new Ext.tree.AsyncTreeNode({
            		text: '学生信息管理',
            		children: [{
	                    id: 'all_student',
	                    text: '管理学生信息',
	                    iconCls: 'tree-first',
	                    leaf: true
	                }]
            	})
            }]
       },{
            title:'BGU和意见管理',
            border:false,
            iconCls:'advise_mgr',
            items: [{
            	id: 'advise_mgr',
            	xtype: 'treepanel',
            	renderTo: 'tree5',
            	border:false,
            	//隐藏根节点
            	rootVisible: false,
            	root: new Ext.tree.AsyncTreeNode({
            		text: 'Bug和建议管理',
            		children: [{
	                    id: 'suggest_info',
	                    text: '管理Bug和建议',
	                    iconCls: 'tree-first',
	                    leaf: true
	                }]
            	})
            }]
       }*/],
       //底端工具栏
       bbar: [{
			text : '开始',
			iconCls : 'begin-icon',
			menu : new Ext.menu.Menu({
				items : [{
					text : '关于系统',
					iconCls : 'question_icon',
					handler : function() {
						new Ext.Window({
							closeAction : 'close',
							resizable : false,
							bodyStyle : 'padding: 7',
							modal : true,
							title : '关于本系统',
							html : '<br/>&nbsp;&nbsp;本系统是互联网发展的产物,<br/>它让老师和学生可以在课后很好的在线交流和互动,<br/>' +
									'希望使用本系统的老师和同学能够喜欢本系统,<br/>若遇到问题或者有好的建议希望能给我们留言,<br/>' +
									'我们会及时解决,为你们提供更好更贴切的服务,<br/>营造一个互动、自主、愉快的学习氛围!<br/>',
							width : 300,
							height : 200
						}).show();
					}
				}, {
					text : '退出系统',
					iconCls : 'del_icon',
					handler : function() {
						Ext.Msg.confirm('操作提示', '您确定要退出本系统?', function(btn) {
							if ('yes' == btn) {
								window.location.href = 'loginOut.do';								
							}
						});
					}
				}]
			})
		}] 
   	});
   	
   	/*中部，主要功能的显示区，使用选项面板*/
   	var center_cmp = new Ext.TabPanel({
    	id: 'center_part',
        region:'center',
        deferredRender:false,
        //可滚动的
        enableTabScroll: true,	
        activeTab:0,
        items:[{
            contentEl:'home',
            title: 'Home',
            iconCls: 'home_icon',
            autoScroll:true
        }],
        //给TabPanel增加右键菜单
        listeners:{
        	 //传进去的三个参数分别为:这个tabpanel(tabsDemo),当前标签页,事件对象e
			"contextmenu": function(tabPanel, myitem, e){
                    var closeMenu = new Ext.menu.Menu([{
	                     text:"关闭当前页",
	                     handler:function(){
	                        tabPanel.remove(myitem);
	                     }
                    },{
                         text:"关闭其他所有页",
                         handler:function(){
                            //循环遍历
                            tabPanel.items.each(function(item){
                                 if(item.closable && item!=myitem){
                                    //可以关闭的其他所有标签页全部关掉
                                    tabPanel.remove(item);
                                 }
                            });
                         }
                    }, {
                    	 text:"关闭所有页",
                         handler:function(){
                            //循环遍历
                            tabPanel.items.each(function(item){
                                 if(item.closable)
                                 {
                                    //可以关闭所有标签页全部关掉
                                    tabPanel.remove(item);
                                 }
                            });
                         }
                    }]);
                    //显示在当前位置
                    closeMenu.showAt(e.getPoint());
             }	
        }                
 	});
   	
   	//整体布局    	 
   	var viewport = new Ext.Viewport({
        layout:'border',
        items:[ top_cmp, foot_cmp, right_cmp, left_cmp, center_cmp ]
   	});
   	
   	//右边的工具栏默认是隐藏收缩的
   	Ext.getCmp('tool_bar').collapse();
   	
   	
   	/*---------------事件部分----------------*/
	/*-------------------------------------*/
   	
   	/*工具类，根据男女风格*/
    var sexRenderer = function(value) {
        if (value == '男') {
            return '<span style="color:green;font-weight:bold;">男</span>';
        } else if (value == '女') {
            return '<span style="color:red;font-weight:bold;">女</span>';
        }
    }; 
   	
   	/*********************师生互动版块模块开始**********************/
	Ext.getCmp("stu_tch_interact").on('click', function(node, event) {
   		if (node.isLeaf()) {		//判断点击的是树的叶子节点
			event.stopEvent();
			
			//获取点击的菜单项的id
			var node_id = node.id;
			//获取被点击的菜单项的text
			var node_text = node.text;
			
			if (node_id == 'ask_answer_column') {			//浏览所有提问
				
				//从TabPanel获取此id的对象，看看tab是否已经打开
				var tab = center_cmp.getComponent(node_id);		         	
				
				if (!tab) {				//如果没有打开	
					
					//显示等待保存的提示信息
					Ext.MessageBox.show({
							title: '请等待',
							msg: '正在加载，请稍等...',
							progress: true,								        
							width: 260,
							wait:true,
							icon: 'mb_download_icon',
							animEl: 'saving',
							waitConfig: {
								interval: 200,  //interval进度的频率
								duration: 1000,	//执行进度的持续时间，超过这个时间后，interval失效，不再产生进度效果，但进度框也不会消失。
								fn: function(){	//时间到后执行
									Ext.MessageBox.hide();	//让进度条消失
								}
							}
					});
					
					/***定义带插件RowExpander的表格上的工具条的按钮的处理函数***/	
					
					//定义RowExpander显示格式的按钮的处理函数
					var styleButtonFn = function(btn){
						if (styleButton.getText() == '详细模式') {
							//展开分组表格的分组
							topicGrid.getView().expandAllGroups();
							for (var i = 0; i < topicGrid.getStore().getCount(); i++) {		
								styleButton.setText('简洁模式');
								styleButton.setIconClass("pithy_icon");
								expander.expandRow(i);
							}
						} else if (styleButton.getText() == '简洁模式') {
							//收缩分组表格的分组
							topicGrid.getView().collapseAllGroups();
							for (var i = 0; i < topicGrid.getStore().getCount(); i++) {		
								styleButton.setText('详细模式');
								styleButton.setIconClass("minute_icon");
								expander.collapseRow(i);
							}							
						}
					}
					
					//定义显示回复按钮的处理函数			
					
					/******************定义显示问题或讨论回复的窗口****************/
					//定义窗口中的表格
					//定义表格Record样式
					var replyRecord = Ext.data.Record.create([
						{name: 'id', type: 'int', mapping: 'id'},
						{name: 'author', type: 'string', mapping: 'author'},
						{name: 'role', type: 'string', mapping: 'role'},							
						{name: 'pubdate', type: 'date', mapping: 'pubdate', dateFormat: 'Y-m-dTH:i:s'},
						{name: 'content', type: 'string', mapping: 'content'}
					]);
					
					//定义加号里面的内容显示格式
					var replyExpander = new Ext.grid.RowExpander({
						tpl : new Ext.Template(
							'<p>&nbsp;</p>',
							'<p><b>回复内容：</b></p>',
							'<p>&nbsp;</p>',
							'<p>{content}</p><br/><br/>'
						)
					});
					//定义表格列样式
					var replyColums = new Ext.grid.ColumnModel([
						//加上上面定义的expander
						replyExpander,
					{
						id: 'id',
						header: '编号',
						dataIndex: 'id',
						type: 'int'
					},{
						id: 'author',
						header: '回复人',
						dataIndex: 'author',
						type: 'string'
					},{
						id: 'role',
						header: '角色',
						dataIndex: 'role',
						type: 'string'
					},{
						id: 'pubdate',
						header: '回复时间',
						dataIndex: 'pubdate',
						type: 'date',
						width: 140,
						renderer: Ext.util.Format.dateRenderer('Y年m月d日 H时i分s秒')
					}]);
					replyColums.defaultSortable = false;
					
					//定义表格顶端工具栏	
					//显示风格选择按钮
					var replyStyleButton = new Ext.Button({
						text: '详细模式',
						tooltip: '切换显示模式',
						iconCls:'minute_icon',
						handler: function(btn) {
							if (btn.getText() == '详细模式') {
								//展开分组表格的分组
								replyGrid.getView().expandAllGroups();
								for (var i = 0; i < replyGrid.getStore().getCount(); i++) {		
									btn.setText('简洁模式');
									btn.setIconClass("pithy_icon");
									replyExpander.expandRow(i);
								}
							} else if (btn.getText() == '简洁模式') {
								//收缩分组表格的分组
								replyGrid.getView().collapseAllGroups();
								for (var i = 0; i < replyGrid.getStore().getCount(); i++) {		
									btn.setText('详细模式');
									btn.setIconClass("minute_icon");
									replyExpander.collapseRow(i);
								}							
							}
						}						
					});
					//删除回复按钮
					var replyDeleteButton = new Ext.Button({
						text: '删除',
						tooltip: '删除选择回复',
						iconCls:'del_icon',
						handler: function(btn) {
							//获取表格中选中的那行（使用getSelected()只选择选中的多个行的第一行）返回的是Record类型
							var selectedCol = replyGrid.getSelectionModel().getSelected();
							
							if (selectedCol == undefined) {				//如果没有选择任何一行
							
								Ext.Msg.alert("错误提示", "请选择一行你要删除的记录！");
								
							} else {									//选择的行删除
								//先提醒用户是否要删除
								Ext.Msg.confirm("提醒信息", "你确定要删除你选择的记录吗？", function(btn) {
									//如果用户确定删除
									if (btn == 'yes') {
										//获取选择的id
										var del_id = selectedCol.get("id");									
										//发送到后台处理
										Ext.Ajax.request({
											url: 'reply_mgr.do?cmd=delete',
											success: function(response) {
												var obj = Ext.decode(response.responseText);
												if (typeof(obj) != 'undefined') {
													if (obj.result == 'success') {
														Ext.Msg.alert("操作结果", "恭喜，删除记录成功！");
														//刷新表格数据，看看删除效果
														replyGrid.getStore().reload();
													} else {
														Ext.Msg.alert("操作结果", "抱歉，删除记录失败！请重新尝试！");
													}
												} else {
													Ext.Msg.alert("操作结果", "抱歉，删除记录失败！请重新尝试！");
												}
												
											},
											failure: function() {
												Ext.Msg.alert("操作结果", "抱歉，删除记录失败！请重新尝试！");
											},
											params: {id: del_id}		
										});
									}
								});
							}				
						}						
					});
					var replyTopToolbar = new Ext.Toolbar({
						items: [replyStyleButton, '-', replyDeleteButton]
					});
					
					//定义Stroe(使用的是GroupingStore产生分组表格，按是老师或学生分组)
					var replyStore = new Ext.data.GroupingStore({
						proxy: new Ext.data.HttpProxy({url:'reply_mgr.do?cmd=show'}),
						reader: new Ext.data.JsonReader({
							totalProperty: 'totalProperty',
							root: 'root'
						}, replyRecord),
						//分组的列
						groupField: 'role',
						//分组必须设置的，排序的列
						sortInfo: {field: 'id', direction: 'desc'}
					});		
					
					//定义表格
					var replyGrid = new Ext.grid.GridPanel({
						loadMask: true,
						//使得表格强制fit父容器
						viewConfig: {
							forceFit: true
						},						
						store: replyStore,
						cm: replyColums,
						sm: new Ext.grid.RowSelectionModel(),
						//设置分组View
						view: new Ext.grid.GroupingView({
							forceFit:true,
					        //显示这个分组有多少项
					        groupTextTpl: '{text} ({[values.rs.length]} {["条记录"]})'
						}),
						//添加顶端的工具栏
						tbar: replyTopToolbar,
						//添加底部分页条（bbar-->bottom bar）
						bbar: new Ext.PagingToolbar({
							pageSize: 10,
							store: replyStore,
							displayInfo: true,
							displayMsg: '显示第 {0} --> {1} 条记录，共 {2} 条记录',
							emptyMsg: "没有记录"
						}),
						//扩展插件
						plugins: replyExpander,
						collapsible: true,
						animCollapse: false
					});
					
					//定义窗口显示回复
					var reply_win = Ext.getCmp("reply_win");
					
					if (!reply_win) {
						reply_win = new Ext.Window({
							id: 'reply_win',
							title: '查看问题回复',
							layout: 'fit',
							width:700,
							height:500,
							//设置当点击X按钮时候，是隐藏还是销毁
							closeAction:'hide',
							//标题栏不允许超出浏览器范围
							constrainHeader: true,
							//开启蒙板效果
							modal: true,
							items: [replyGrid]								
						});
					}					
					/****************定义显示问题或讨论回复的窗口结束****************/
					
					//定义显示回复按钮的处理函数		
					var showButtonFn = function(){
						
						//获取表格中选中的那行（使用getSelected()只选择选中的多个行的第一行）返回的是Record类型
						var selectedCol = topicGrid.getSelectionModel().getSelected();
						
						if (selectedCol == undefined) {				//如果没有选择任何一行
						
							Ext.Msg.alert("错误提示", "请选择你要查看回复的问题！");
							
						} else {									//选择的行查看回复
							var close_id = selectedCol.get("id");
							//设置所回复的问题的id
							replyStore.baseParams.topic_id = close_id;		
							//加载数据
							replyStore.load({params:{start: 0, limit: 10}});
							//定义窗口显示回复
							reply_win.show();
						}
					}
					//定义提出新问题按钮					
					var newQuestionButtonFn = function(){
						
							//判断是否存在，不存在才创建
							var add_question_win = Ext.getCmp("add_question_win");
							
							if (!add_question_win) {
								/************弹出窗口(提出新问题)*************/
								//创建表单
								var newQuestionForm = new Ext.form.FormPanel({
									url: 'topic_mgr.do?cmd=add&flag=question',
									labelAlign: 'right',
									labelWidth: 80,
									frame: true,
									defaultType: 'textfield',						        
									items: [{
										xtype: 'fieldset',
										title: '提问基本信息',
										autoHeight: true,
										defaultType: 'textfield',
										//统一设置宽度和验证
										defaults: {					
											//不为空
											allowBlank: false
										},									
										items: [{
											fieldLabel: '标题',
											name: 'title',
											width: 300,
											//最大长度
											maxLength: 20,
											//最小长度
											minLength: 2
										},{
											xtype: 'htmleditor',
											id: 'newQuestionEditor',
											fieldLabel: '内容',
											name: 'content',
											height: 200,
											//禁止编辑源代码
											enableSourceEdit: false,
											//这个是编码转换..
											anchor: '98%' 
											
										}]						     
									}]							        
								});	
								
								//定义弹出窗口
								add_question_win = new Ext.Window({
									id: 'add_question_win',
									title: '提出新问题',
									width:650,
									height:350,
									//设置当点击X按钮时候，是隐藏还是销毁
									closeAction:'hide',
									//不允许超出浏览器范围
									constrain: true,
									//开启蒙板效果
									modal: true,
									buttonAlign: 'center',
									items: [newQuestionForm],
									buttons: [{
										text:'保存',
										iconCls: 'submit_icon',
										//提交表单
										handler: function () {											
											//判断HtmlEditor即内容的输入是否为空
											var contentValue = Ext.getCmp("newQuestionEditor").getValue();
											if (Ext.isEmpty(contentValue.Trim())) {
												Ext.Msg.alert("错误信息", "请输入您提出问题的内容!");
												return;
											}
											newQuestionForm.getForm().submit({
												success: function (newQuestionForm, action) {
													Ext.Msg.alert("操作结果", action.result.msg);		
						                            //重载Store
													topicStore.reload();
													//重置newQuestionForm中的数据
													newQuestionForm.reset();
													//关闭窗口（隐藏）
													add_question_win.hide();
												},
												failure: function (newQuestionForm, action) {
													Ext.Msg.alert("操作结果", action.result.msg);
												}											
											});
											//显示等待保存的提示信息
							        		Ext.MessageBox.show({
							        				title: '请等待',
				                                    msg: '正在保存，请稍等...',
				                                    progress: true,								        
											        width: 240,
											        wait:true,
											        icon: 'mb_waiting_icon',
											        animEl: 'saving',
											        waitConfig: {
											        	interval: 200,  //interval进度的频率
											        	duration: 1000,	//执行进度的持续时间，超过这个时间后，interval失效，不再产生进度效果，但进度框也不会消失。
														fn: function(){	//时间到后执行
						                                 	Ext.MessageBox.hide();	//让进度条消失
						                                }
											        }
				                            });
										}						       	 	
									}, {
										text:'重置',
										iconCls: 'reset_icon',
										handler: function () {
											newQuestionForm.getForm().reset();
										}	
									}, {
										text:'取消',
										iconCls: 'revoke_icon',
										handler: function () {
											add_question_win.hide();
										}	
									}]
								});
								/************弹出窗口(提出新问题)结束*************/
							}
							
							add_question_win.show();
					}
					//定义回复问题按钮的处理函数					
					var answerButtonFn = function(){
						
						//获取表格中选中的那行（使用getSelected()只选择选中的多个行的第一行）返回的是Record类型
						var selectedCol = topicGrid.getSelectionModel().getSelected();
						
						if (selectedCol == undefined) {				//如果没有选择任何一行
						
							Ext.Msg.alert("错误提示", "请选择你要回答的问题！");
							
						} else {									//选择的行回答问题
							var isClosed = selectedCol.get("status");
							
							var topic_id = selectedCol.get("id");
							
							//看看用户是否选择的是未解决的问题去回答
							if (isClosed == '已解决') {
								Ext.Msg.alert("错误提示", "此问题已解决，请选择未解决的问题回答！");
							} else {																	
								
								//判断是否存在，不存在才创建
								var reply_question_win = Ext.getCmp("reply_question_win");
								
								if (!reply_question_win) {
									
									/************弹出窗口(回复问题)*************/
									//创建表单
									var replyForm = new Ext.form.FormPanel({
										url: 'reply_mgr.do?cmd=add&flag=question',
										labelAlign: 'right',
										labelWidth: 80,
										frame: true,
										defaultType: 'textfield',						        
										items: [{
											xtype: 'fieldset',
											title: '回答基本信息',
											autoHeight: true,
											defaultType: 'textfield',
											//统一设置宽度和验证
											defaults: {					
												//不为空
												allowBlank: false
											},									
											items: [{
												id: 'topic_hidden',
												name: 'topic_id',
												xtype: 'hidden',
												value: topic_id
											}, {
												id: 'replyEditor',
												xtype: 'htmleditor',											
												fieldLabel: '内容',
												name: 'content',
												height: 200,
												//禁止编辑源代码
												enableSourceEdit: false,
												//这个是编码转换..
												anchor: '98%' 
												
											}]						     
										}]							        
									});	
									//定义弹出窗口
									reply_question_win = new Ext.Window({
										id: 'reply_question_win',
										title: '回答问题',
										width:640,
										height:320,
										//设置当点击X按钮时候，是隐藏还是销毁
										closeAction:'hide',
										//不允许超出浏览器范围
										constrain: true,
										//开启蒙板效果
										modal: true,
										buttonAlign: 'center',
										items: [replyForm],
										buttons: [{
											text:'保存',
											iconCls: 'submit_icon',
											//提交表单
											handler: function () {			
												//判断HtmlEditor即内容的输入是否为空
												var contentValue = replyForm.getForm().findField("replyEditor").getValue();
												if (contentValue.Trim() == "") {
													Ext.Msg.alert("错误信息", "请输入您提出问题的内容!");
													return;
												}
												replyForm.getForm().submit({
													success: function (replyForm, action) {
														Ext.Msg.alert("操作结果", action.result.msg);	
														//刷新表格数据，看看删除效果
														topicGrid.getStore().reload();
														//重置newQuestionForm中的数据
														replyForm.reset();
														//关闭窗口（隐藏）
														reply_question_win.hide();
													},
													failure: function (replyForm, action) {
														Ext.Msg.alert("操作结果", action.result.msg);
													}											
												});
												//显示等待保存的提示信息
								        		Ext.MessageBox.show({
								        				title: '请等待',
					                                    msg: '正在保存，请稍等...',
					                                    progress: true,								        
												        width: 240,
												        wait:true,
												        icon: 'mb_waiting_icon',
												        animEl: 'saving',
												        waitConfig: {
												        	interval: 200,  //interval进度的频率
												        	duration: 1000,	//执行进度的持续时间，超过这个时间后，interval失效，不再产生进度效果，但进度框也不会消失。
															fn: function(){	//时间到后执行
							                                 	Ext.MessageBox.hide();	//让进度条消失
							                                }
												        }
					                            });
											}						       	 	
										}, {
											text:'重置',
											iconCls: 'reset_icon',
											handler: function () {
												replyForm.getForm().reset();
											}	
										}, {
											text:'取消',
											iconCls: 'revoke_icon',
											handler: function () {
												reply_question_win.hide();
											}	
										}]
									});
									/************弹出窗口(回复问题)结束*************/									
								}
								reply_question_win.show();
								
								//设置隐藏域的值(注意要在Window显示show之后，给其中的表单赋值)												
								Ext.getCmp("topic_hidden").setValue(topic_id);
								
							}
						}
					}		
					
					//定义关闭问题按钮的处理函数					
					var endButtonFn = function(){
						
						//获取表格中选中的那行（使用getSelected()只选择选中的多个行的第一行）返回的是Record类型
						var selectedCol = topicGrid.getSelectionModel().getSelected();
						
						if (selectedCol == undefined) {				//如果没有选择任何一行
						
							Ext.Msg.alert("错误提示", "请选择你要关闭的问题！");
							
						} else {									//选择的行关闭问题	
							var isClosed = selectedCol.get("status");
							//看看用户是否选择的是未解决的问题去关闭
							if (isClosed == '已解决') {
								Ext.Msg.alert("错误提示", "请选择未解决的问题！");
							} else {
								//先提醒用户是否要删除
								Ext.Msg.confirm("提醒信息", "你确定此问题已经解决并关闭此问题吗？", function(btn) {
									//如果用户确定删除
									if (btn == 'yes') {
										//获取选择的id
										var close_id = selectedCol.get("id");									
										//发送到后台处理
										Ext.Ajax.request({
											url: 'topic_mgr.do?cmd=close',
											success: function(response) {
												var obj = Ext.decode(response.responseText);
												if (typeof(obj) != 'undefined') {
													if (obj.result == 'success') {
														Ext.Msg.alert("操作结果", "恭喜，关闭问题成功！");
														//刷新表格数据，看看删除效果
														topicGrid.getStore().reload();
													} else {
														Ext.Msg.alert("操作结果", "抱歉，关闭问题失败！请重新尝试！");
													}
												} else {
													Ext.Msg.alert("操作结果", "抱歉，关闭问题失败！请重新尝试！");
												}
												
											},
											failure: function() {
												Ext.Msg.alert("操作结果", "抱歉，关闭问题失败！请重新尝试！");
											},
											params: {id: close_id}		
										});
									}
								});		
							}
						}
					}					
					
					//定义删除按钮的处理函数
					var deleteButtonFn = function(){
						//获取表格中选中的那行（使用getSelected()只选择选中的多个行的第一行）返回的是Record类型
						var selectedCol = topicGrid.getSelectionModel().getSelected();
						
						if (selectedCol == undefined) {				//如果没有选择任何一行
						
							Ext.Msg.alert("错误提示", "请选择一行你要删除的记录！");
							
						} else {									//选择的行删除
							//先提醒用户是否要删除
							Ext.Msg.confirm("提醒信息", "你确定要删除你选择的记录吗？", function(btn) {
								//如果用户确定删除
								if (btn == 'yes') {
									//获取选择的id
									var del_id = selectedCol.get("id");									
									//发送到后台处理
									Ext.Ajax.request({
										url: 'topic_mgr.do?cmd=delete',
										success: function(response) {
											var obj = Ext.decode(response.responseText);
											if (typeof(obj) != 'undefined') {
												if (obj.result == 'success') {
													Ext.Msg.alert("操作结果", "恭喜，删除记录成功！");
													//刷新表格数据，看看删除效果
													topicGrid.getStore().reload();
												} else {
													Ext.Msg.alert("操作结果", "抱歉，删除记录失败！请重新尝试！");
												}
											} else {
												Ext.Msg.alert("操作结果", "抱歉，删除记录失败！请重新尝试！");
											}
											
										},
										failure: function() {
											Ext.Msg.alert("操作结果", "抱歉，删除记录失败！请重新尝试！");
										},
										params: {id: del_id}		
									});
								}
							});
						}						
					}
					
					
					/**定义带插件RowExpander的表格上的工具条的按钮的处理函数结束**/			
					
					/******定义所有提问带ext插件RowExpander的表格*********/	
					
					//定义表格Record样式
					var topicRecord = Ext.data.Record.create([
						{name: 'id', type: 'int', mapping: 'id'},
						{name: 'title', type: 'string', mapping: 'title'},
						{name: 'status', type: 'string', mapping: 'status'},
						{name: 'reply_count', type: 'int', mapping: 'reply_count'},
						{name: 'author', type: 'string', mapping: 'author'},
						{name: 'role', type: 'string', mapping: 'role'},							
						{name: 'pubdate', type: 'date', mapping: 'pubdate', dateFormat: 'Y-m-dTH:i:s'},
						{name: 'content', type: 'string', mapping: 'content'}
					]);
					
					//定义加号里面的内容显示格式
					var expander = new Ext.grid.RowExpander({
						tpl : new Ext.Template(
							'<p>&nbsp;</p>',
							'<p><b>提问具体内容：</b></p>',
							'<p>&nbsp;</p>',
							'<p>{content}</p><br /><br />'
						)
					});
					
					//定义表格列样式
					var topicColums = new Ext.grid.ColumnModel([
						//加上上面定义的expander
						expander,
					{
						id: 'id',
						header: '编号',
						dataIndex: 'id',
						type: 'int'
					},{
						id: 'title',
						header: '标题',
						dataIndex: 'title',
						type: 'string'
					},{
						id: 'status',
						header: '状态',
						dataIndex: 'status',
						type: 'string'
					},{
						id: 'reply_count',
						header: '回复数',
						dataIndex: 'reply_count',
						type: 'int'
					},{
						id: 'author',
						header: '作者',
						dataIndex: 'author',
						type: 'string'
					},{
						id: 'role',
						header: '角色',
						dataIndex: 'role',
						type: 'string'
					},{
						id: 'pubdate',
						header: '提问时间',
						dataIndex: 'pubdate',
						type: 'date',
						width: 140,
						renderer: Ext.util.Format.dateRenderer('Y年m月d日 H时i分s秒')
					}]);
					topicColums.defaultSortable = false;
					
					//定义Stroe(使用的是GroupingStore产生分组表格，按是否问题已经解决分组)
					var topicStore = new Ext.data.GroupingStore({
						proxy: new Ext.data.HttpProxy({url:'topic_mgr.do?cmd=show'}),
						reader: new Ext.data.JsonReader({
							totalProperty: 'totalProperty',
							root: 'root'
						}, topicRecord),
						baseParams: {flag: 'question'},
						//分组的列
						groupField: 'status',
						//分组必须设置的，排序的列
						sortInfo: {field: 'id', direction: 'desc'}
					});
					topicStore.load({params:{start: 0, limit: 10}});				    
					
					//定义表格顶端工具栏	
					//显示风格选择按钮
					var styleButton = new Ext.Button({
						text: '详细模式',
						tooltip: '切换显示模式',
						iconCls:'minute_icon',
						handler: styleButtonFn
					});
					//查看回复按钮
					var showButton = new Ext.Button({
						text: '查看回复',
						tooltip: '查看此问题的回复',
						iconCls:'show_icon',
						handler: showButtonFn
					});
					//提出问题按钮
					var newQuestionButton = new Ext.Button({
						text: '提出新问题',
						tooltip: '提出新的问题',
						iconCls:'question_icon',
						handler: newQuestionButtonFn
					});
					//回答问题按钮
					var answerButton = new Ext.Button({
						text: '我来回答',
						tooltip: '我来回答此问题',
						iconCls:'answer_icon',
						handler: answerButtonFn
					});
					//关闭问题按钮
					var endButton = new Ext.Button({
						text: '关闭问题',
						tooltip: '关闭选中问题，设置为已解决',
						iconCls:'close_icon',
						handler: endButtonFn
					});
					//删除问题按钮
					var deleteButton = new Ext.Button({
						text: '删除',
						tooltip: '删除选中的讨论话题',
						iconCls:'del_icon',
						handler: deleteButtonFn
					});
					var topToolbar = new Ext.Toolbar({
						items: [styleButton, '-', showButton, '-', newQuestionButton, '-', answerButton, '-', endButton, '-', deleteButton]
					});
					
					//定义表格
					var topicGrid = new Ext.grid.GridPanel({
						loadMask: true,
						//使得表格强制fit父容器
						viewConfig: {
							forceFit: true
						},
						store: topicStore,
						cm: topicColums,
						sm: new Ext.grid.RowSelectionModel(),
						//设置分组View
						view: new Ext.grid.GroupingView({
							forceFit:true,
					        //显示这个分组有多少项
					        groupTextTpl: '{text} ({[values.rs.length]} {["条记录"]})'
						}),
						//添加顶端的工具栏
						tbar: topToolbar,
						//添加底部分页条（bbar-->bottom bar）
						bbar: new Ext.PagingToolbar({
							pageSize: 10,
							store: topicStore,
							displayInfo: true,
							displayMsg: '显示第 {0} --> {1} 条记录，共 {2} 条记录',
							emptyMsg: "没有记录"
						}),
						//扩展插件
						plugins: expander,
						collapsible: true,
						animCollapse: false
					});						
						
					/*****定义显示bug和建议的带ext插件RowExpander的表格结束*******/						
						
					/*****************添加此表格到TabPanel*****************/
					tab = center_cmp.add({
						//使用点击菜单的id，这样方便事件处理
						id: node_id,
						//标题为被点击的菜单项的text
						title: node_text,
						closable:true,
						iconCls: 'nor_icon',
						autoScroll:true,
						layout: 'fit',
						items: [topicGrid]
					});		  
					/***************添加此表格到TabPanel结束***************/
					
				}
				//设置此新增Tab为活动的Tab
				center_cmp.setActiveTab(tab);
				
			} else if (node_id == 'discuss_column') {		//浏览所有讨论
				
				//从TabPanel获取此id的对象，看看tab是否已经打开
				var tab = center_cmp.getComponent(node_id);		         	
				
				if (!tab) {				//如果没有打开	
					//显示等待保存的提示信息
					Ext.MessageBox.show({
							title: '请等待',
							msg: '正在加载，请稍等...',
							progress: true,								        
							width: 260,
							wait:true,
							icon: 'mb_download_icon',
							animEl: 'saving',
							waitConfig: {
								interval: 200,  //interval进度的频率
								duration: 1000,	//执行进度的持续时间，超过这个时间后，interval失效，不再产生进度效果，但进度框也不会消失。
								fn: function(){	//时间到后执行
									Ext.MessageBox.hide();	//让进度条消失
								}
							}
					});
					
					/***定义带插件RowExpander的表格上的工具条的按钮的处理函数***/	
					
					//定义RowExpander显示格式的按钮的处理函数
					var styleButtonFn = function(btn){
						if (styleButton.getText() == '详细模式') {
							//展开分组表格的分组
							topicGrid.getView().expandAllGroups();
							for (var i = 0; i < topicGrid.getStore().getCount(); i++) {		
								styleButton.setText('简洁模式');
								styleButton.setIconClass("pithy_icon");
								expander.expandRow(i);
							}
						} else if (styleButton.getText() == '简洁模式') {
							//收缩分组表格的分组
							topicGrid.getView().collapseAllGroups();
							for (var i = 0; i < topicGrid.getStore().getCount(); i++) {		
								styleButton.setText('详细模式');
								styleButton.setIconClass("minute_icon");
								expander.collapseRow(i);
							}							
						}
					}
										
					//定义显示回复按钮的处理函数			
					
					/******************定义显示问题或讨论回复的窗口****************/
					//定义窗口中的表格
					//定义表格Record样式
					var replyRecord = Ext.data.Record.create([
						{name: 'id', type: 'int', mapping: 'id'},
						{name: 'author', type: 'string', mapping: 'author'},
						{name: 'role', type: 'string', mapping: 'role'},							
						{name: 'pubdate', type: 'date', mapping: 'pubdate', dateFormat: 'Y-m-dTH:i:s'},
						{name: 'content', type: 'string', mapping: 'content'}
					]);
					
					//定义加号里面的内容显示格式
					var replyExpander = new Ext.grid.RowExpander({
						tpl : new Ext.Template(
							'<p>&nbsp;</p>',
							'<p><b>回复内容：</b></p>',
							'<p>&nbsp;</p>',
							'<p>{content}</p><br/><br/>'
						)
					});
					//定义表格列样式
					var replyColums = new Ext.grid.ColumnModel([
						//加上上面定义的expander
						replyExpander,
					{
						id: 'id',
						header: '编号',
						dataIndex: 'id',
						type: 'int'
					},{
						id: 'author',
						header: '回复人',
						dataIndex: 'author',
						type: 'string'
					},{
						id: 'role',
						header: '角色',
						dataIndex: 'role',
						type: 'string'
					},{
						id: 'pubdate',
						header: '回复时间',
						dataIndex: 'pubdate',
						type: 'date',
						width: 140,
						renderer: Ext.util.Format.dateRenderer('Y年m月d日 H时i分s秒')
					}]);
					replyColums.defaultSortable = false;
					
					//定义表格顶端工具栏	
					//显示风格选择按钮
					var replyStyleButton = new Ext.Button({
						text: '详细模式',
						tooltip: '切换显示模式',
						iconCls:'minute_icon',
						handler: function(btn) {
							if (btn.getText() == '详细模式') {
								//展开分组表格的分组
								replyGrid.getView().expandAllGroups();
								for (var i = 0; i < replyGrid.getStore().getCount(); i++) {		
									btn.setText('简洁模式');
									btn.setIconClass("pithy_icon");
									replyExpander.expandRow(i);
								}
							} else if (btn.getText() == '简洁模式') {
								//收缩分组表格的分组
								replyGrid.getView().collapseAllGroups();
								for (var i = 0; i < replyGrid.getStore().getCount(); i++) {		
									btn.setText('详细模式');
									btn.setIconClass("minute_icon");
									replyExpander.collapseRow(i);
								}							
							}
						}						
					});
					//删除回复按钮
					var replyDeleteButton = new Ext.Button({
						text: '删除',
						tooltip: '删除选择回复',
						iconCls:'del_icon',
						handler: function(btn) {
							//获取表格中选中的那行（使用getSelected()只选择选中的多个行的第一行）返回的是Record类型
							var selectedCol = replyGrid.getSelectionModel().getSelected();
							
							if (selectedCol == undefined) {				//如果没有选择任何一行
							
								Ext.Msg.alert("错误提示", "请选择一行你要删除的记录！");
								
							} else {									//选择的行删除
								//先提醒用户是否要删除
								Ext.Msg.confirm("提醒信息", "你确定要删除你选择的记录吗？", function(btn) {
									//如果用户确定删除
									if (btn == 'yes') {
										//获取选择的id
										var del_id = selectedCol.get("id");									
										//发送到后台处理
										Ext.Ajax.request({
											url: 'reply_mgr.do?cmd=delete',
											success: function(response) {
												var obj = Ext.decode(response.responseText);
												if (typeof(obj) != 'undefined') {
													if (obj.result == 'success') {
														Ext.Msg.alert("操作结果", "恭喜，删除记录成功！");
														//刷新表格数据，看看删除效果
														replyGrid.getStore().reload();
													} else {
														Ext.Msg.alert("操作结果", "抱歉，删除记录失败！请重新尝试！");
													}
												} else {
													Ext.Msg.alert("操作结果", "抱歉，删除记录失败！请重新尝试！");
												}
												
											},
											failure: function() {
												Ext.Msg.alert("操作结果", "抱歉，删除记录失败！请重新尝试！");
											},
											params: {id: del_id}		
										});
									}
								});
							}				
						}						
					});
					var replyTopToolbar = new Ext.Toolbar({
						items: [replyStyleButton, '-', replyDeleteButton]
					});
					
					//定义Stroe(使用的是GroupingStore产生分组表格，按是老师或学生分组)
					var replyStore = new Ext.data.GroupingStore({
						proxy: new Ext.data.HttpProxy({url:'reply_mgr.do?cmd=show'}),
						reader: new Ext.data.JsonReader({
							totalProperty: 'totalProperty',
							root: 'root'
						}, replyRecord),
						//分组的列
						groupField: 'role',
						//分组必须设置的，排序的列
						sortInfo: {field: 'id', direction: 'desc'}
					});		
					
					//定义表格
					var replyGrid = new Ext.grid.GridPanel({
						loadMask: true,
						//使得表格强制fit父容器
						viewConfig: {
							forceFit: true
						},						
						store: replyStore,
						cm: replyColums,
						sm: new Ext.grid.RowSelectionModel(),
						//设置分组View
						view: new Ext.grid.GroupingView({
							forceFit:true,
					        //显示这个分组有多少项
					        groupTextTpl: '{text} ({[values.rs.length]} {["条记录"]})'
						}),
						//添加顶端的工具栏
						tbar: replyTopToolbar,
						//添加底部分页条（bbar-->bottom bar）
						bbar: new Ext.PagingToolbar({
							pageSize: 10,
							store: replyStore,
							displayInfo: true,
							displayMsg: '显示第 {0} --> {1} 条记录，共 {2} 条记录',
							emptyMsg: "没有记录"
						}),
						//扩展插件
						plugins: replyExpander,
						collapsible: true,
						animCollapse: false
					});
					
					//定义窗口显示回复
					var discuss_reply_win = Ext.getCmp("discuss_reply_win");
					
					if (!discuss_reply_win) {
						discuss_reply_win = new Ext.Window({
							id: 'discuss_reply_win',
							title: '查看讨论话题回复',
							layout: 'fit',
							width:700,
							height:500,
							//设置当点击X按钮时候，是隐藏还是销毁
							closeAction:'hide',
							//标题栏不允许超出浏览器范围
							constrainHeader: true,
							//开启蒙板效果
							modal: true,
							items: [replyGrid]								
						});
					}					
					/****************定义显示讨论话题或讨论回复的窗口结束****************/
					
					//定义显示回复按钮的处理函数		
					var showButtonFn = function(){
						
						//获取表格中选中的那行（使用getSelected()只选择选中的多个行的第一行）返回的是Record类型
						var selectedCol = topicGrid.getSelectionModel().getSelected();
						
						if (selectedCol == undefined) {				//如果没有选择任何一行
						
							Ext.Msg.alert("错误提示", "请选择你要查看回复的讨论话题！");
							
						} else {									//选择的行查看回复
							var close_id = selectedCol.get("id");
							//设置所回复的讨论话题的id
							replyStore.baseParams.topic_id = close_id;		
							//加载数据
							replyStore.load({params:{start: 0, limit: 10}});
							//定义窗口显示回复
							discuss_reply_win.show();
						}
					}
					
					//定义发起新话题按钮					
					var newDisscussButtonFn = function(){
						
							//判断是否存在，不存在才创建
							var add_discussion_win = Ext.getCmp("add_discussion_win");
							
							if (!add_discussion_win) {
								/************弹出窗口(提出新话题)*************/
								//创建表单
								var newDiscussionForm = new Ext.form.FormPanel({
									url: 'topic_mgr.do?cmd=add&flag=discuss',
									labelAlign: 'right',
									labelWidth: 80,
									frame: true,
									defaultType: 'textfield',						        
									items: [{
										xtype: 'fieldset',
										title: '讨论基本信息',
										autoHeight: true,
										defaultType: 'textfield',
										//统一设置宽度和验证
										defaults: {					
											//不为空
											allowBlank: false
										},									
										items: [{
											fieldLabel: '标题',
											name: 'title',
											width: 300,
											//最大长度
											maxLength: 20,
											//最小长度
											minLength: 2
										},{
											xtype: 'htmleditor',
											id: 'newDiscussEditor',
											fieldLabel: '内容',
											name: 'content',
											height: 200,
											//禁止编辑源代码
											enableSourceEdit: false,
											//这个是编码转换..
											anchor: '98%' 
											
										}]						     
									}]							        
								});	
								
								//定义弹出窗口
								add_discussion_win = new Ext.Window({
									id: 'add_discussion_win',
									title: '发起新讨论',
									width:650,
									height:350,
									//设置当点击X按钮时候，是隐藏还是销毁
									closeAction:'hide',
									//不允许超出浏览器范围
									constrain: true,
									//开启蒙板效果
									modal: true,
									buttonAlign: 'center',
									items: [newDiscussionForm],
									buttons: [{
										text:'保存',
										iconCls: 'submit_icon',
										//提交表单
										handler: function () {											
											//判断HtmlEditor即内容的输入是否为空
											var contentValue = Ext.getCmp("newDiscussEditor").getValue();
											if (contentValue.Trim() == "") {
												Ext.Msg.alert("错误信息", "请输入您发起讨论话题的内容!");
												return;
											}
											newDiscussionForm.getForm().submit({
												success: function (newDiscussionForm, action) {
													Ext.Msg.alert("操作结果", action.result.msg);		
						                            //重载Store
													topicStore.reload();
													//重置newQuestionForm中的数据
													newDiscussionForm.reset();
													//关闭窗口（隐藏）
													add_discussion_win.hide();
												},
												failure: function (newDiscussionForm, action) {
													Ext.Msg.alert("操作结果", action.result.msg);
												}											
											});
											//显示等待保存的提示信息
							        		Ext.MessageBox.show({
							        				title: '请等待',
				                                    msg: '正在保存，请稍等...',
				                                    progress: true,								        
											        width: 240,
											        wait:true,
											        icon: 'mb_waiting_icon',
											        animEl: 'saving',
											        waitConfig: {
											        	interval: 200,  //interval进度的频率
											        	duration: 1000,	//执行进度的持续时间，超过这个时间后，interval失效，不再产生进度效果，但进度框也不会消失。
														fn: function(){	//时间到后执行
						                                 	Ext.MessageBox.hide();	//让进度条消失
						                                }
											        }
				                            });
										}						       	 	
									}, {
										text:'重置',
										iconCls: 'reset_icon',
										handler: function () {
											newDiscussionForm.getForm().reset();
										}	
									}, {
										text:'取消',
										iconCls: 'revoke_icon',
										handler: function () {
											add_discussion_win.hide();
										}	
									}]
								});
								/************弹出窗口(提出新讨论话题)结束*************/
							}
							
							add_discussion_win.show();
					}
					
					//定义回复讨论话题按钮的处理函数					
					var answerDiscussionButtonFn = function(){
						
						//获取表格中选中的那行（使用getSelected()只选择选中的多个行的第一行）返回的是Record类型
						var selectedCol = topicGrid.getSelectionModel().getSelected();
						
						if (selectedCol == undefined) {				//如果没有选择任何一行
						
							Ext.Msg.alert("错误提示", "请选择你要参与的讨论！");
							
						} else {									//选择的行回答讨论话题
							var isClosed = selectedCol.get("status");
							
							var topic_id = selectedCol.get("id");
							
							//看看用户是否选择的是未解决的讨论话题去回答
							if (isClosed == '已结束') {
								Ext.Msg.alert("错误提示", "此话题已关闭，请选择未关闭的讨论话题！");
							} else {																	
								
								//判断是否存在，不存在才创建
								var reply_discussion_win = Ext.getCmp("reply_discussion_win");
								
								if (!reply_discussion_win) {
									
									/************弹出窗口(回复讨论话题)*************/
									//创建表单
									var replyForm = new Ext.form.FormPanel({
										url: 'reply_mgr.do?cmd=add&flag=discuss',
										labelAlign: 'right',
										labelWidth: 80,
										frame: true,
										defaultType: 'textfield',						        
										items: [{
											xtype: 'fieldset',
											title: '讨论基本信息',
											autoHeight: true,
											defaultType: 'textfield',
											//统一设置宽度和验证
											defaults: {					
												//不为空
												allowBlank: false
											},									
											items: [{
												id: 'topic_discuss_hidden',
												name: 'topic_id',
												xtype: 'hidden',
												value: topic_id
											}, {
												id: 'reply_discuss_Editor',
												xtype: 'htmleditor',											
												fieldLabel: '内容',
												name: 'content',
												height: 200,
												//禁止编辑源代码
												enableSourceEdit: false,
												//这个是编码转换..
												anchor: '98%' 
												
											}]						     
										}]							        
									});	
									//定义弹出窗口
									reply_discussion_win = new Ext.Window({
										id: 'reply_discussion_win',
										title: '参与讨论',
										width:640,
										height:320,
										//设置当点击X按钮时候，是隐藏还是销毁
										closeAction:'hide',
										//不允许超出浏览器范围
										constrain: true,
										//开启蒙板效果
										modal: true,
										buttonAlign: 'center',
										items: [replyForm],
										buttons: [{
											text:'保存',
											iconCls: 'submit_icon',
											//提交表单
											handler: function () {			
												//判断HtmlEditor即内容的输入是否为空
												var contentValue = replyForm.getForm().findField("reply_discuss_Editor").getValue();
												if (contentValue.Trim() == "") {
													Ext.Msg.alert("错误信息", "请输入您回复讨论话题的内容!");
													return;
												}
												replyForm.getForm().submit({
													success: function (replyForm, action) {
														Ext.Msg.alert("操作结果", action.result.msg);	
														//刷新表格数据，看看删除效果
														topicGrid.getStore().reload();
														//重置newQuestionForm中的数据
														replyForm.reset();
														//关闭窗口（隐藏）
														reply_discussion_win.hide();
													},
													failure: function (replyForm, action) {
														Ext.Msg.alert("操作结果", action.result.msg);
													}											
												});
												//显示等待保存的提示信息
								        		Ext.MessageBox.show({
								        				title: '请等待',
					                                    msg: '正在保存，请稍等...',
					                                    progress: true,								        
												        width: 240,
												        wait:true,
												        icon: 'mb_waiting_icon',
												        animEl: 'saving',
												        waitConfig: {
												        	interval: 200,  //interval进度的频率
												        	duration: 1000,	//执行进度的持续时间，超过这个时间后，interval失效，不再产生进度效果，但进度框也不会消失。
															fn: function(){	//时间到后执行
							                                 	Ext.MessageBox.hide();	//让进度条消失
							                                }
												        }
					                            });
											}						       	 	
										}, {
											text:'重置',
											iconCls: 'reset_icon',
											handler: function () {
												replyForm.getForm().reset();
											}	
										}, {
											text:'取消',
											iconCls: 'revoke_icon',
											handler: function () {
												reply_discussion_win.hide();
											}	
										}]
									});
									/************弹出窗口(回复讨论话题)结束*************/									
								}
								reply_discussion_win.show();
								
								//设置隐藏域的值(注意要在Window显示show之后，给其中的表单赋值)												
								Ext.getCmp("topic_discuss_hidden").setValue(topic_id);
								
							}
						}
					}		
					
					//定义关闭讨论话题按钮的处理函数					
					var endButtonFn = function(){
						
						//获取表格中选中的那行（使用getSelected()只选择选中的多个行的第一行）返回的是Record类型
						var selectedCol = topicGrid.getSelectionModel().getSelected();
						
						if (selectedCol == undefined) {				//如果没有选择任何一行
						
							Ext.Msg.alert("错误提示", "请选择你要关闭的讨论话题！");
							
						} else {									//选择的行关闭讨论话题
							var isClosed = selectedCol.get("status");
							//看看用户是否选择的是未关闭的讨论话题去关闭
							if (isClosed == '已关闭') {
								Ext.Msg.alert("错误提示", "请选择进行中的讨论话题！");
							} else {
								//先提醒用户是否要删除
								Ext.Msg.confirm("提醒信息", "你确定关闭此讨论话题吗？", function(btn) {
									//如果用户确定删除
									if (btn == 'yes') {
										//获取选择的id
										var close_id = selectedCol.get("id");									
										//发送到后台处理
										Ext.Ajax.request({
											url: 'topic_mgr.do?cmd=close',
											success: function(response) {
												var obj = Ext.decode(response.responseText);
												if (typeof(obj) != 'undefined') {
													if (obj.result == 'success') {
														Ext.Msg.alert("操作结果", "恭喜，关闭讨论成功！");
														//刷新表格数据，看看删除效果
														topicGrid.getStore().reload();
													} else {
														Ext.Msg.alert("操作结果", "抱歉，关闭讨论失败！请重新尝试！");
													}
												} else {
													Ext.Msg.alert("操作结果", "抱歉，关闭讨论失败！请重新尝试！");
												}
												
											},
											failure: function() {
												Ext.Msg.alert("操作结果", "抱歉，关闭讨论失败！请重新尝试！");
											},
											params: {id: close_id}		
										});
									}
								});		
							}
						}
					}										
					
					//定义删除按钮的处理函数
					var deleteButtonFn = function(){
						//获取表格中选中的那行（使用getSelected()只选择选中的多个行的第一行）返回的是Record类型
						var selectedCol = topicGrid.getSelectionModel().getSelected();
						
						if (selectedCol == undefined) {				//如果没有选择任何一行
						
							Ext.Msg.alert("错误提示", "请选择一行你要删除的记录！");
							
						} else {									//选择的行删除
							//先提醒用户是否要删除
							Ext.Msg.confirm("提醒信息", "你确定要删除你选择的记录吗？", function(btn) {
								//如果用户确定删除
								if (btn == 'yes') {
									//获取选择的id
									var del_id = selectedCol.get("id");									
									//发送到后台处理
									Ext.Ajax.request({
										url: 'topic_mgr.do?cmd=delete',
										success: function(response) {
											var obj = Ext.decode(response.responseText);
											if (typeof(obj) != 'undefined') {
												if (obj.result == 'success') {
													Ext.Msg.alert("操作结果", "恭喜，删除记录成功！");
													//刷新表格数据，看看删除效果
													topicGrid.getStore().reload();
												} else {
													Ext.Msg.alert("操作结果", "抱歉，删除记录失败！请重新尝试！");
												}
											} else {
												Ext.Msg.alert("操作结果", "抱歉，删除记录失败！请重新尝试！");
											}
											
										},
										failure: function() {
											Ext.Msg.alert("操作结果", "抱歉，删除记录失败！请重新尝试！");
										},
										params: {id: del_id}		
									});
								}
							});
						}						
					}					
					
					/**定义带插件RowExpander的表格上的工具条的按钮的处理函数结束**/			
					
					/******定义所有提问带ext插件RowExpander的表格*********/	
					
						//定义表格Record样式
						var topicRecord = Ext.data.Record.create([
							{name: 'id', type: 'int', mapping: 'id'},
							{name: 'title', type: 'string', mapping: 'title'},
							{name: 'status', type: 'string', mapping: 'status'},
							{name: 'reply_count', type: 'int', mapping: 'reply_count'},
							{name: 'author', type: 'string', mapping: 'author'},
							{name: 'role', type: 'string', mapping: 'role'},							
							{name: 'pubdate', type: 'date', mapping: 'pubdate', dateFormat: 'Y-m-dTH:i:s'},
							{name: 'content', type: 'string', mapping: 'content'}
						]);
						
						//定义加号里面的内容显示格式
						var expander = new Ext.grid.RowExpander({
							tpl : new Ext.Template(
								'<p>&nbsp;</p>',
								'<p><b>讨论话题：</b></p>',
								'<p>&nbsp;</p>',
								'<p>{content}</p><br /><br />'
							)
						});
						
						//定义表格列样式
						var topicColums = new Ext.grid.ColumnModel([
							//加上上面定义的expander
							expander,
						{
							id: 'id',
							header: '编号',
							dataIndex: 'id',
							type: 'int'
						},{
							id: 'title',
							header: '标题',
							dataIndex: 'title',
							type: 'string'
						},{
							id: 'status',
							header: '状态',
							dataIndex: 'status',
							type: 'string'
						},{
							id: 'reply_count',
							header: '回复数',
							dataIndex: 'reply_count',
							type: 'int'
						},{
							id: 'author',
							header: '作者',
							dataIndex: 'author',
							type: 'string'
						},{
							id: 'role',
							header: '角色',
							dataIndex: 'role',
							type: 'string'
						},{
							id: 'pubdate',
							header: '提出时间',
							dataIndex: 'pubdate',
							type: 'date',
							width: 140,
							renderer: Ext.util.Format.dateRenderer('Y年m月d日 H时i分s秒')
						}]);
						topicColums.defaultSortable = false;
						
						//定义Stroe(使用的是GroupingStore产生分组表格，按是否讨论结束分组)
						var topicStore = new Ext.data.GroupingStore({
							proxy: new Ext.data.HttpProxy({url:'topic_mgr.do?cmd=show'}),
							reader: new Ext.data.JsonReader({
								totalProperty: 'totalProperty',
								root: 'root'
							}, topicRecord),
							baseParams: {flag: 'discuss'},
							//分组的列
							groupField: 'status',
							//分组必须设置的，排序的列
							sortInfo: {field: 'id', direction: 'desc'}
						});
						topicStore.load({params:{start: 0, limit: 10}});				    
						
						//定义表格顶端工具栏	
						//显示风格选择按钮
						var styleButton = new Ext.Button({
							text: '详细模式',
							tooltip: '切换显示模式',
							iconCls:'minute_icon',
							handler: styleButtonFn
						});
						//查看讨论话题按钮
						var showButton = new Ext.Button({
							text: '查看回复',
							tooltip: '查看此问题的回复',
							iconCls:'show_icon',
							handler: showButtonFn
						});
						//提出讨论话题按钮
						var newQuestionButton = new Ext.Button({
							text: '发起讨论',
							tooltip: '发起讨论话题',
							iconCls:'question_icon',
							handler: newDisscussButtonFn
						});
						//回答讨论话题按钮
						var answerButton = new Ext.Button({
							text: '参与讨论',
							tooltip: '我来参与讨论',
							iconCls:'answer_icon',
							handler: answerDiscussionButtonFn
						});
						//关闭讨论话题按钮
						var endButton = new Ext.Button({
							text: '关闭讨论话题',
							tooltip: '关闭选中的讨论话题',
							iconCls:'close_icon',
							handler: endButtonFn
						});
						//删除讨论话题按钮
						var deleteButton = new Ext.Button({
							text: '删除',
							tooltip: '删除选中的讨论话题',
							iconCls:'del_icon',
							handler: deleteButtonFn
						});
						var topToolbar = new Ext.Toolbar({
							items: [styleButton, '-', showButton, '-', newQuestionButton, '-', answerButton, '-', endButton, '-', deleteButton]
						});
						
						//定义表格
						var topicGrid = new Ext.grid.GridPanel({
							loadMask: true,
							//使得表格强制fit父容器
							viewConfig: {
								forceFit: true
							},
							store: topicStore,
							cm: topicColums,
							sm: new Ext.grid.RowSelectionModel(),
							//设置分组View
							view: new Ext.grid.GroupingView({
								forceFit:true,
						        //显示这个分组有多少项
						        groupTextTpl: '{text} ({[values.rs.length]} {["条记录"]})'
							}),
							//添加顶端的工具栏
							tbar: topToolbar,
							//添加底部分页条（bbar-->bottom bar）
							bbar: new Ext.PagingToolbar({
								pageSize: 10,
								store: topicStore,
								displayInfo: true,
								displayMsg: '显示第 {0} --> {1} 条记录，共 {2} 条记录',
								emptyMsg: "没有记录"
							}),
							//扩展插件
							plugins: expander,
							collapsible: true,
							animCollapse: false
						});
						
					/*****定义显示bug和建议的带ext插件RowExpander的表格结束*******/						
						
					/*****************添加此表格到TabPanel*****************/
					tab = center_cmp.add({
						//使用点击菜单的id，这样方便事件处理
						id: node_id,
						//标题为被点击的菜单项的text
						title: node_text,
						closable:true,
						iconCls: 'nor_icon',
						autoScroll:true,
						layout: 'fit',
						items: [topicGrid]
					});		  
					/***************添加此表格到TabPanel结束***************/
					
				}
				//设置此新增Tab为活动的Tab
				center_cmp.setActiveTab(tab);
				
			}
   		}
	});
   	/***********************师生互动版块模块结束*******************/
	
	
	/*********************个人信息管理版块模块开始******************/
	
	Ext.getCmp("ownInfo_mgr").on('click', function(node, event) {
       	if (node.isLeaf()) {		//判断点击的是树的叶子节点
        	event.stopEvent();
        	
        	//获取点击的菜单项的id
           	var node_id = node.id;
           	//获取被点击的菜单项的text
           	var node_text = node.text;
       		
           	if (node_id == 'own_info') {			//管理个人信息
           		//从TabPanel获取此id的对象，看看tab是否已经打开
				var tab = center_cmp.getComponent(node_id);		         	
				
				if (!tab) {				//如果没有打开
					
					//显示等待保存的提示信息
	        		Ext.MessageBox.show({
	        				title: '请等待',
                            msg: '正在加载，请稍等...',
                            progress: true,								        
					        width: 260,
					        wait:true,
					        icon: 'mb_download_icon',
					        animEl: 'saving',
					        waitConfig: {
					        	interval: 200,  //interval进度的频率
					        	duration: 1000,	//执行进度的持续时间，超过这个时间后，interval失效，不再产生进度效果，但进度框也不会消失。
								fn: function(){	//时间到后执行
                                 	Ext.MessageBox.hide();	//让进度条消失
                                }
					        }
                    });
					
					/*****************表格定义*********************/
					//表格列样式
					var mgr_columns = new Ext.grid.ColumnModel([
						new Ext.grid.RowNumberer(),
						{header: '编号', dataIndex: 'id'},
				        {header: '姓名', dataIndex: 'name'},
				        {header: '性别', dataIndex: 'sex', renderer: sexRenderer},
				        {header: '登陆账号', dataIndex: 'nickname'},
				        {header: '密码', dataIndex: 'password'},
				        {header: '所属专业', dataIndex: 'major'},
				        {header: '专业编号', dataIndex: 'major_id'}
					]);
					mgr_columns.defaultSortable = false;		
									
					//表格数据格式
					var managerRecord = Ext.data.Record.create([
						 {name: 'id', type: 'int'},
				        {name: 'name', type: 'string'},
				        {name: 'sex', type: 'string'},
				        {name: 'nickname', type: 'string'},
				        {name: 'password', type: 'string'},
				        {name: 'major', type: 'string'},
				        {name: 'major_id', type: 'int'}
					]);
					
					//到后台获取数据库中的数据,用于填充表格
					var mgr_store = new Ext.data.Store({
						proxy: new Ext.data.HttpProxy({url: 'tch_self_mgr.do?cmd=show'}),
						reader: new Ext.data.JsonReader({
							root: 'root'
						}, managerRecord),
						remoteSort: true
					});
					//加载数据，并发送参数到服务器端
					mgr_store.load();		
					//表格定义
					var mgr_grid = new Ext.grid.GridPanel({
						//遮罩提示功能
						loadMask: true,
						store: mgr_store,
						cm: mgr_columns,
						//使得表格强制fit父容器
						viewConfig: {
							forceFit: true
						}
					});
					/*****************表格定义结束*********************/
					
					/***************添加此表格到TabPanel***************/
					tab = center_cmp.add({
						//使用点击菜单的id，这样方便事件处理
						id: node_id,
						//标题为被点击的菜单项的text
						title: node_text,
						closable:true,
						iconCls: 'nor_icon',
						autoScroll:true,
						layout: 'fit',
						items: [mgr_grid]
					});		  
					/***************添加此表格到TabPanel结束***************/									
				}						
				//设置此新增Tab为活动的Tab
				center_cmp.setActiveTab(tab);
				
           	} else if (node_id == 'modify_info') {	  
           	
           		//看看弹出窗口是否存在，已经渲染，没有就创建
           		var teacher_win = Ext.getCmp("teacher_win");
           		if (!teacher_win) {
	           		/********修改个人信息的弹出窗口**********/															
					//创建表单
					var teacherForm = new Ext.form.FormPanel({
						url: 'tch_self_mgr.do?cmd=modify',
						id: 'teacherForm',
						labelAlign: 'right',
						labelWidth: 80,
						frame: true,
						defaultType: 'textfield',						        
						items: [{
							//保存个人id的隐藏域，用于修改个人信息用
							xtype: 'hidden',
							name: 'id'
						}, {
							xtype: 'fieldset',
							title: '基本信息',
							autoHeight: true,
							defaultType: 'textfield',
							//统一设置宽度和验证
							defaults: {
								width: 170,
								//不为空
								allowBlank: false
							},									
							items: [{
								fieldLabel: '姓名',
								name: 'name',
								//最大长度
								maxLength: 4,
								//最小长度
								minLength: 2,
								//只能输入汉字（使用自定义的验证）
								regex: /^[\u4E00-\u9FA5]+$/,
								regexText: '只能输入汉字'
							},{
								fieldLabel: '性别',
								name: 'sex',
								//最大长度
								maxLength: 1,
								//只能输入汉字（使用自定义的验证）
								regex: /^[男|女]/,
								regexText: '只能输入男或女'
							},{
								fieldLabel: '登陆账号',
								name: 'nickname',
								//最大长度
					            maxLength: 11,
					            //最小长度
					            minLength: 4,
					            //只能输入字母和数字
					            vtype: 'alphanum'
							},{
								fieldLabel: '密码',
								name: 'password',
								//最大长度
								maxLength: 12,
								//最小长度
								minLength: 4,
								//只能输入字母和数字
								vtype: 'alphanum'
							}]						     
						}]							        
					});
					//定义弹出窗口
					teacher_win = new Ext.Window({
						id: 'teacher_win',
						title: '修改个人信息',
						width:350,
						height:220,
						//设置当点击X按钮时候，是隐藏还是销毁
						closeAction:'hide',
						//不允许超出浏览器范围
						constrain: true,
						//开启蒙板效果
						modal: true,
						buttonAlign: 'center',
						items: [teacherForm],
						buttons: [{
							text:'修改',
							iconCls: 'submit_icon',
							//提交表单
							handler: function () {
								//如果表单验证成功，则显示保存的等待，和提交form
					       		if (teacherForm.getForm().isValid()) {
					       			//提交表单
									teacherForm.getForm().submit({											
										success: function (teacherForm, action) {
											Ext.Msg.alert("操作结果", action.result.msg, function(btn) {
												if (btn == 'ok') {
													//重置teacherForm中的数据
													teacherForm.reset();
													//关闭窗口（隐藏）
													teacher_win.hide();
													//登出，让用户重新登陆
													top.window.location.href='loginOut.do';
												}
											});												
										},
										failure: function (teacherForm, action) {
											Ext.Msg.alert("操作结果", action.result.msg);
										}
									});
									//显示等待保存的提示信息
					        		Ext.MessageBox.show({
					        				title: '请等待',
		                                    msg: '正在保存，请稍等...',
		                                    progress: true,								        
									        width: 240,
									        wait:true,
									        icon: 'mb_waiting_icon',
									        animEl: 'saving',
									        waitConfig: {
									        	interval: 200,  //interval进度的频率
									        	duration: 1000,	//执行进度的持续时间，超过这个时间后，interval失效，不再产生进度效果，但进度框也不会消失。
												fn: function(){	//时间到后执行
				                                 	Ext.MessageBox.hide();	//让进度条消失
				                                }
									        }
		                            });									
					       		}
							}						       	 	
						}, {
							text:'重置',
							iconCls: 'reset_icon',
							handler: function () {
								teacherForm.getForm().reset();
							}	
						}, {
							text:'取消',
							iconCls: 'revoke_icon',
							handler: function () {
								teacher_win.hide();
							}	
						}]
					});
					/******************弹出窗口结束*****************/     
				}    	
           		//显示弹出窗口，修改信息		           		
				teacher_win.show(); 
				//到后台获取数据
				Ext.Ajax.request({
					url: 'tch_self_mgr.do?cmd=get',
					success: function(response) {
						var obj = Ext.decode(response.responseText);
						if (typeof(obj) != 'undefined') {
							//填充到form中
							Ext.getCmp("teacherForm").getForm().setValues({
								id: obj.id,
								name: obj.name,
								sex: obj.sex,
								nickname: obj.nickname,
								password: obj.password
							});
						} else {
							Ext.Msg.alert("提示信息", "抱歉，读取个人信息失败！");
						}								
					},
					failure: function() {
						Ext.Msg.alert("提示信息", "抱歉，读取个人信息失败！");
					}	
				});      		
           	}
      	}
    });
	
	/*********************个人信息管理版块模块结束******************/
    
   
    /*********************公告信息管理版块模块结束******************/
    
    Ext.getCmp("notice_mgr").on('click', function(node, event) {
   		if (node.isLeaf()) {		//判断点击的是树的叶子节点
			event.stopEvent();
			
			//获取点击的菜单项的id
			var node_id = node.id;
			//获取被点击的菜单项的text
			var node_text = node.text;
			
			if (node_id == 'mgr_notice') {			//浏览所有提问
				
				//从TabPanel获取此id的对象，看看tab是否已经打开
				var tab = center_cmp.getComponent(node_id);		         	
				
				if (!tab) {				//如果没有打开	
					
					//显示等待保存的提示信息
					Ext.MessageBox.show({
							title: '请等待',
							msg: '正在加载，请稍等...',
							progress: true,								        
							width: 260,
							wait:true,
							icon: 'mb_download_icon',
							animEl: 'saving',
							waitConfig: {
								interval: 200,  //interval进度的频率
								duration: 1000,	//执行进度的持续时间，超过这个时间后，interval失效，不再产生进度效果，但进度框也不会消失。
								fn: function(){	//时间到后执行
									Ext.MessageBox.hide();	//让进度条消失
								}
							}
					});
					
					/***定义带插件RowExpander的表格上的工具条的按钮的处理函数***/	
					
					//定义RowExpander显示格式的按钮的处理函数
					var styleButtonFn = function(btn){
						if (styleButton.getText() == '详细模式') {
							//展开分组表格的分组
							noticeGrid.getView().expandAllGroups();
							for (var i = 0; i < noticeGrid.getStore().getCount(); i++) {		
								styleButton.setText('简洁模式');
								styleButton.setIconClass("pithy_icon");
								expander.expandRow(i);
							}
						} else if (styleButton.getText() == '简洁模式') {
							//收缩分组表格的分组
							noticeGrid.getView().collapseAllGroups();
							for (var i = 0; i < noticeGrid.getStore().getCount(); i++) {		
								styleButton.setText('详细模式');
								styleButton.setIconClass("minute_icon");
								expander.collapseRow(i);
							}							
						}
					}
					/********弹出窗口(修改公告信息和新添公告共用)********/
					//创建Notice表单
					var noticeForm = new Ext.form.FormPanel({
				        labelAlign: 'right',
				        labelWidth: 80,
				        frame: true,
				        defaultType: 'textfield',						        
				        items: [{
				        	//保存老师id的隐藏域，用于修改老师信息用
				        	xtype: 'hidden',
				        	name: 'id'
				        }, {
				        	xtype: 'fieldset',
							title: '基本信息',
							autoHeight: true,
							defaultType: 'textfield',
							//统一设置宽度和验证
					        defaults: {
					        	width: 170,
					        	//不为空
						        allowBlank: false
					        },									
							items: [{
					            fieldLabel: '过期时间',
					            xtype: 'datefield',
					            name: 'end_time'
					        },{
								xtype: 'htmleditor',
								id: 'newNoticeEditor',
								fieldLabel: '公告内容',
								name: 'content',
								height: 200,
								//禁止编辑源代码
								enableSourceEdit: false,
								//这个是编码转换..
								anchor: '98%' 
								
							}]						     
				        }]							        
				    });
				    //定义弹出窗口
					var notice_win = new Ext.Window({
						id: 'notice_win',
						title: '发布新公告',
				        width:650,
				        height:350,
				        //设置当点击X按钮时候，是隐藏还是销毁
				        closeAction:'hide',
				        //不允许超出浏览器范围
				        constrain: true,
				        //开启蒙板效果
				        modal: true,
				        buttonAlign: 'center',
				        items: [noticeForm],
				        buttons: [{
					       	text:'保存',
					       	iconCls: 'submit_icon',
					       	//提交表单
					       	handler: function () {
					       		//如果表单验证成功，则显示保存的等待，和提交form
					       		if (noticeForm.getForm().isValid()) {
					       			//判断HtmlEditor即内容的输入是否为空
									var contentValue = Ext.getCmp("newNoticeEditor").getValue();
									if (Ext.isEmpty(contentValue.Trim())) {
										Ext.Msg.alert("错误信息", "请输入您要发布的公告内容!");
										return;
									}
					       			//提交表单
					       			noticeForm.getForm().submit({
					        			success: function (noticeForm, action) {
					        				Ext.Msg.alert("操作结果", action.result.msg);
					        				//重置noticeForm中的数据
					        				noticeForm.reset();
					        				//关闭窗口（隐藏）
					        				notice_win.hide();
					        				//刷新表格数据，看看修改或添加效果
					        				noticeGrid.getStore().reload();
					        			},
					        			failure: function (noticeForm, action) {
					        				Ext.Msg.alert("操作结果", action.result.msg);
					        			}
					        		});
					       			//显示等待保存的提示信息
					        		Ext.MessageBox.show({
					        				title: '请等待',
		                                    msg: '正在保存，请稍等...',
		                                    progress: true,								        
									        width: 240,
									        wait:true,
									        icon: 'mb_waiting_icon',
									        animEl: 'saving',
									        waitConfig: {
									        	interval: 200,  //interval进度的频率
									        	duration: 1000,	//执行进度的持续时间，超过这个时间后，interval失效，不再产生进度效果，但进度框也不会消失。
												fn: function(){	//时间到后执行
				                                 	Ext.MessageBox.hide();	//让进度条消失
				                                }
									        }
		                            });
					       		}	
				        	}						       	 	
				        }, {
				        	text:'重置',
				        	iconCls: 'reset_icon',
				        	handler: function () {
				        		noticeForm.getForm().reset();
				        	}	
				        }, {
				        	text:'取消',
				        	iconCls: 'revoke_icon',
				        	handler: function () {
				        		notice_win.hide();
				        	}	
				        }]
				    });
				    
					
					//发布新公告
					var newNoticeButtonFn = function() {
						//修改form的提交地址
						noticeForm.getForm().url = 'notice_mgr.do?cmd=add';	
						noticeForm.getForm().reset();	
						notice_win.setTitle("发布新公告");		
					    notice_win.show();	
					}
					//编辑选中公告
					var editButtonFn = function() {
						//获取表格中选中的那行（使用getSelected()只选择选中的多个行的第一行）返回的是Record类型
						var selectedCol = noticeGrid.getSelectionModel().getSelected();
						
						if (selectedCol == undefined) {				//如果没有选择任何一行
						
							Ext.Msg.alert("错误提示", "请选择一行你要编辑的记录！");
							
						} else {
							//修改form的体交地址
							noticeForm.getForm().url = 'notice_mgr.do?cmd=modify';
							notice_win.setTitle("修改公告信息");
							notice_win.show();	
							
							/***注意，一定要先显示窗口，以及其中的From在给Form设值，才可以****/
							
							//把表格中选中行的数据填充到表单中，并显示Window							
							noticeForm.getForm().setValues({
								id: selectedCol.get("id"),
								end_time: selectedCol.get("end_time"),
								content: selectedCol.get("content")
							});
						}
					}
					//删除选中公告
					var deleteButtonFn = function() {
						//获取表格中选中的那行（使用getSelected()只选择选中的多个行的第一行）返回的是Record类型
						var selectedCol = noticeGrid.getSelectionModel().getSelected();
						
						if (selectedCol == undefined) {				//如果没有选择任何一行
						
							Ext.Msg.alert("错误提示", "请选择一行你要删除的记录！");
							
						} else {
							//先提醒用户是否要删除
							Ext.Msg.confirm("提醒信息", "你确定要删除你选择的记录吗？", function(btn) {
								//如果用户确定删除
								if (btn == 'yes') {
									//把要删除的所有选中的id
									var del_id = selectedCol.get("id");
									
									//发送到后台处理
									Ext.Ajax.request({
										url: 'notice_mgr.do?cmd=delete',
										success: function(response) {
											var obj = Ext.decode(response.responseText);
											if (typeof(obj) != 'undefined') {
												if (obj.result == 'success') {
													Ext.Msg.alert("操作结果", "恭喜，删除公告成功！");
													//刷新表格数据，看看删除效果
						        					noticeGrid.getStore().reload();
												} else {
													Ext.Msg.alert("操作结果", "抱歉，删除公告失败！请重新尝试！");
												}
											} else {
												Ext.Msg.alert("操作结果", "抱歉，删除公告失败！请重新尝试！");
											}
											
										},
										failure: function() {
											Ext.Msg.alert("操作结果", "抱歉，删除公告失败！请重新尝试！");
										},
										params: {id: del_id}										
										
									});
								}							
							});
						}
					}			
					
					
					/**定义带插件RowExpander的表格上的工具条的按钮的处理函数结束**/			
					
					/******定义所有提问带ext插件RowExpander的表格*********/	
					
					//定义表格Record样式
					var noticeRecord = Ext.data.Record.create([
						{name: 'id', type: 'int', mapping: 'id'},
						{name: 'pub_time', type: 'date', mapping: 'pub_time', dateFormat: 'Y-m-dTH:i:s'},
						{name: 'end_time', type: 'date', mapping: 'end_time', dateFormat: 'Y-m-dTH:i:s'},
						{name: 'status', type: 'string', mapping: 'status'},
						{name: 'author', type: 'string', mapping: 'author'},
						{name: 'role', type: 'string', mapping: 'role'},							
						{name: 'content', type: 'string', mapping: 'content'}
					]);
					
					//定义加号里面的内容显示格式
					var expander = new Ext.grid.RowExpander({
						tpl : new Ext.Template(
							'<p>&nbsp;</p>',
							'<p><b>公告内容：</b></p>',
							'<p>&nbsp;</p>',
							'<p>{content}</p><br /><br />'
						)
					});
					
					//定义表格列样式
					var noticeColums = new Ext.grid.ColumnModel([
						//加上上面定义的expander
						expander,
					{
						id: 'id',
						header: '编号',
						dataIndex: 'id',
						type: 'int'
					},{
						id: 'status',
						header: '状态',
						dataIndex: 'status',
						type: 'string'
					},{
						id: 'pub_time',
						header: '公布时间',
						dataIndex: 'pub_time',
						type: 'date',
						width: 140,
						renderer: Ext.util.Format.dateRenderer('Y年m月d日 H时i分s秒')
					},{
						id: 'end_time',
						header: '到期时间',
						dataIndex: 'end_time',
						type: 'date',
						width: 140,
						renderer: Ext.util.Format.dateRenderer('Y年m月d日 H时i分s秒')
					},{
						id: 'author',
						header: '发布人',
						dataIndex: 'author',
						type: 'string'
					},{
						id: 'role',
						header: '角色',
						dataIndex: 'role',
						type: 'string'
					}]);
					noticeColums.defaultSortable = false;
					
					//定义Stroe(使用的是GroupingStore产生分组表格，按是否问题已经解决分组)
					var noticeStore = new Ext.data.GroupingStore({
						proxy: new Ext.data.HttpProxy({url:'notice_mgr.do?cmd=show'}),
						reader: new Ext.data.JsonReader({
							totalProperty: 'totalProperty',
							root: 'root'
						}, noticeRecord),
						//分组的列
						groupField: 'status',
						//分组必须设置的，排序的列
						sortInfo: {field: 'id', direction: 'desc'}
					});
					noticeStore.load({params:{start: 0, limit: 10}});	
					
					//定义表格顶端工具栏	
					//显示风格选择按钮
					var styleButton = new Ext.Button({
						text: '详细模式',
						tooltip: '切换显示模式',
						iconCls:'minute_icon',
						handler: styleButtonFn
					});	
					var newNoticeButton = new Ext.Button({
						text: '发布',
						tooltip: '发布新公告',
						iconCls:'add_icon',
						handler: newNoticeButtonFn
					});
					var editButton = new Ext.Button({
						text: '编辑',
						tooltip: '编辑选中的公告',
						iconCls:'edit_icon',
						handler: editButtonFn
					});					
					var deleteButton = new Ext.Button({
						text: '删除',
						tooltip: '删除选中的公告',
						iconCls:'del_icon',
						handler: deleteButtonFn
					});
					var flashButton = new Ext.Button({
						text: '刷新',
						tooltip: '刷新本页内容',
						iconCls:'flush_icon',
						handler: function() {
					    	noticeGrid.getStore().reload();
					    }
					});
					var topToolbar = new Ext.Toolbar({
						items: [styleButton, '-', newNoticeButton, '-', editButton, '-', deleteButton, '-', flashButton]
					});
					
					//定义表格
					var noticeGrid = new Ext.grid.GridPanel({
						loadMask: true,
						//使得表格强制fit父容器
						viewConfig: {
							forceFit: true
						},
						store: noticeStore,
						cm: noticeColums,
						sm: new Ext.grid.RowSelectionModel(),
						//设置分组View
						view: new Ext.grid.GroupingView({
							forceFit:true,
					        //显示这个分组有多少项
					        groupTextTpl: '{text} ({[values.rs.length]} {["条记录"]})'
						}),
						//添加顶端的工具栏
						tbar: topToolbar,
						//添加底部分页条（bbar-->bottom bar）
						bbar: new Ext.PagingToolbar({
							pageSize: 10,
							store: noticeStore,
							displayInfo: true,
							displayMsg: '显示第 {0} --> {1} 条记录，共 {2} 条记录',
							emptyMsg: "没有记录"
						}),
						//扩展插件
						plugins: expander,
						collapsible: true,
						animCollapse: false
					});
					
					/*****定义显示公告信息的带ext插件RowExpander的表格结束*******/
					/*****************添加此表格到TabPanel*****************/
					tab = center_cmp.add({
						//使用点击菜单的id，这样方便事件处理
						id: node_id,
						//标题为被点击的菜单项的text
						title: node_text,
						closable:true,
						iconCls: 'nor_icon',
						autoScroll:true,
						layout: 'fit',
						items: [noticeGrid]
					});		  
					/***************添加此表格到TabPanel结束***************/
					
				}
				//设置此新增Tab为活动的Tab
				center_cmp.setActiveTab(tab);
			}
   		}
    });    
    /*********************公告信息管理版块模块结束******************/
    
    
     /*********************弹出显示公告信息的窗口开始******************/    
    //发送到后台处理
	Ext.Ajax.request({
		url: 'notice_mgr.do?cmd=display',
		success: function(response) {
			var obj = Ext.decode(response.responseText);
			if (typeof(obj) != 'undefined') {
				if (obj.result == 'success') {
					//公告内容
					var card_items = obj.data; 
					//公告的ids，用以上一步，下一步的处理函数
					var ids = obj.ids;
					var len = ids.length;
					
					//上一步，下一步的处理函数
					var navHandler = function(direction){				
				        var notice_win = Ext.getCmp('noticeWin').layout;
				        var prev = Ext.getCmp('move-prev');
				        var next = Ext.getCmp('move-next');
				        var activeId = notice_win.activeItem.id;
						var len = ids.length;
						//如果只有一条数据则，设置为不可点，返回
						if (len == 1) {
							prev.setDisabled(true);
							next.setDisabled(true);
							return;
						}						
				        for (var i = 0; i < len; i++) {
			        		if (activeId == ids[i]) {			        			
			        			if (i == 0) {
			        				if (direction == 1) {
						                notice_win.setActiveItem(i + 1);
						                prev.setDisabled(false);
					            	}
			        			} else if (i == (len - 1)) {
			        				if (direction == -1) {
						                notice_win.setActiveItem(i - 1);
						                next.setDisabled(false);
						            }
			        			} else if (i == 1) {
			        				if (direction == -1) {
						                notice_win.setActiveItem(i - 1);
						                prev.setDisabled(true);
						            } else {
						                notice_win.setActiveItem(i + 1);
						            }
			        			} else if (i == (len - 2)) {
			        				if (direction == -1) {
						                notice_win.setActiveItem(i - 1);
						            } else {
						                notice_win.setActiveItem(i + 1);
						                next.setDisabled(true);
						            }
			        			} else {
			        				 if (direction == -1) {
						                notice_win.setActiveItem(i - 1);
						            } else {
						                notice_win.setActiveItem(i + 1);
						            }
			        			}			        			
					            break;
			        		}
				        }	
				    };
				    
				    //用于计算弹出窗口的位置，模仿QQ弹出消息框的右下角位置
				    var x_padding = document.body.clientWidth - 300;
				    var y_padding = document.body.clientHeight - 190;
				    
					//定义弹出窗口
					var noticeWin = new Ext.Window({
						id: 'noticeWin',
						title: '通知公告',	
						iconCls:'notice_mgr_icon',
						width: 295,
						height: 190,
						x: x_padding,
						y: y_padding,						
						//使用CardLayout
						layout: 'card',
						//设置当点击X按钮时候，是隐藏还是销毁
						closeAction:'close',
						//不允许超出浏览器范围
						constrain: true,
						//开启蒙板效果（不开）
						modal: false,
						activeItem: 0,
			            defaults: {
			                border:false
			            },
			            //动画效果
						bbar: [{
			                id: 'move-prev',
			                text: '上一条',
			                handler: navHandler.createDelegate(this, [-1]),
			                disabled: true
			            }, '->',{
			                id: 'move-next',
			                text: '下一条',
			                handler: navHandler.createDelegate(this, [1])
			            }],
						items: card_items						
					});
					noticeWin.setAnimateTarget(Ext.get("notice-el"));
					noticeWin.show();
				} 
			} 			
		},
		failure: Ext.emptyFn()		
	});
    
    /*********************弹出显示公告信息的窗口结束******************/
});

